MIDL
Compiler Errors and Warnings
This section
lists MIDL compiler error and warning messages.
An error or
warning message sometimes specifies the name of one or more MIDL compiler mode
switches. The MIDL compiler accepts an IDL file when you use some mode switches
but generates errors for the same file when you do not use mode switches. For
example, you can include ACF attributes in an IDL file when you use the /app_config
switch, but that IDL file will generate an error if you compile without using
the /app_config switch.
Command-line
errors appear in the following format:
Command line error : MIDLnnnn : <error
text>
[<additional error information>]
The
additional-error information field provides context-specific information about
the error. The information in this field depends on the error message. For
example, when an unresolved type-declaration error occurs, the
additional-information field displays the name of the type that could not be
resolved.
Compile-time
warnings appear in the following format:
<FileName>(line#) : warning MIDLnnnn :
<warning text>
[optional context information] :
Compile-time
errors appear in the following format:
<FileName>(line#) : error MIDLnnnn :
<error text>
[optional context information] :
Optional
context information refers to the context in which the error occurred. The MIDL
compiler reports this information to help you quickly find the error in the IDL
file. Context information is generated when the MIDL compiler discovers an
error during semantic analysis of type and procedure signatures.
MIDL1000
: missing source file name
No input file
has been specified in the MIDL compiler command line.
MIDL1001
: cannot open input file
The input
file specified could not be opened.
MIDL1002
: error while reading input file
The system
returned an error while reading the input file.
MIDL1003
: error returned by the C preprocessor
The
preprocessor returned an error. The error message is directed to the output
stream.
MIDL1004
: cannot execute C preprocessor
The operating
system reported an error when it tried to spawn the preprocessor. With MS-DOS,
this error can occur when the argument list exceeds 128 bytes. You can reduce
the size of the argument list by using a response file.
MIDL1005
: cannot find C preprocessor
The MIDL
compiler cannot locate the preprocessor in the specified path or in the path
specified by the PATH environment variable.
MIDL1006
: invalid C preprocessor executable
The specified
preprocessor is not executable or has an invalid executable-file format.
MIDL1007
: switch specified more than once on command line
A switch has
been redefined. The redefined switch is displayed after the error message.
MIDL1008
: unknown switch
An unknown
switch has been specified on the command line.
MIDL1009
: unknown argument ignored
The MIDL
compiler does not recognize the command-line argument as either a switch, a
switch argument, or a filename. The compiler discards the unknown argument and
attempts to continue processing.
MIDL1010
: switch not implemented
The switch is
defined as part of the IDL compiler but is not implemented in Microsoft RPC.
MIDL1011
: argument(s) missing for switch
The switch
expected an argument and the argument is not present. Check the syntax
documentation for the specified switch.
MIDL1012
: argument illegal for switch /
The argument
supplied to the specified switch is illegal.
MIDL1013
: illegal syntax for switch
Several
command-line switches require a space between the switch and the argument,
while other switches require no space between the switch and the argument. The
specified command line violates the defined syntax for that switch.
MIDL1014
: /no_cpp overrides /cpp_cmd and /cpp_opt
The cpp_opt
command has been supplied along with the /no_cpp switch. The /no_cpp
switch takes precedence over the other switches.
MIDL1015
: /no_warn overrides warning-level switch
The no_warn
option has been specified along with the warning-level switch W1, W2, or W3.
The /no_warn switch takes precedence over all other warning-level
switches.
MIDL1016
: cannot create intermediate file
The system
returned an error when the compiler tried to create an intermediate file.
MIDL1018
: out of system file handles
The MIDL
compiler ran out of file handles while opening a file. This error can occur if
too many import files are open and the compiler tries to open an IDL file or an
intermediate file.
MIDL1020
: cannot open response file
The specified
response file could not be opened. The file probably does not exist.
MIDL1021
: illegal character(s) found in response file
A
non-printable character has been detected in the response file. The response
file should contain valid MIDL command-line switches and arguments.
MIDL1023
: nested invocation of response files is illegal
A response
file cannot contain the @ command that directs the MIDL compiler to
process another response file. Although there is no limit on the number of
response files, response files cannot be nested.
MIDL2000
: must specify /c_ext for abstract declarators
Abstract
declarators represent a Microsoft extension to RPC and are not defined in DCE
RPC. To compile a file that includes abstract declarators, you must use the /c_ext
switch.
MIDL2001
: instantiation of data is illegal; you must use extern or static
Declaration
and initialization in the IDL file are not compatible with DCE RPC. This
feature is a Microsoft extension and is not available when you compile in
DCE-compatibility (osf) mode.
MIDL2002
: compiler stack overflow
The compiler
ran out of stack space while processing the IDL file. This problem can occur
when the compiler is processing a complex declaration or expression. To solve
the problem, simplify the complex declaration or expression.
MIDL2003
: redefinition
This error
message can appear under the following circumstances: a type has been
redefined; a procedure prototype has been redefined; a member of a structure or
union of the same name already exists; a parameter of the same name already
exists in the prototype.
MIDL2004
: [auto_handle] binding will be used for procedure
No handle
type has been defined as the default handle type. The compiler assumes that an
auto handle will be used as the binding handle for the specified procedure.
MIDL2005
: out of memory
The compiler
ran out of memory during compilation. Reduce the size or complexity of the IDL
file or allocate more memory to the process.
MIDL2006
: recursive definition
A structure
or union has been recursively defined. This error can occur when a pointer
specification in a nested structure definition is missed.
MIDL2007
: import ignored; file already imported
Importing an
IDL file is an idempotent operation. All but the first import operation are
ignored.
MIDL2008
: sparse enums require /c_ext or /ms_ext switch
Assigning to
enumeration constants is not compatible with DCE RPC. To use the extensions to
RPC that permit assigning values to enumeration constants, use the /c_ext
or /ms_ext switch.
MIDL2009
: undefined symbol
An undefined
symbol has been used in an expression. This error can occur when you use an enum
label that is not defined.
MIDL2010
: type used in ACF file not defined in IDL file
An undefined
type is being used.
MIDL2011
: unresolved type declaration
The type
reported in the additional-information field has not been defined elsewhere in
the IDL file.
MIDL2012
: use of wide-character constants requires /ms_ext or /c_ext
Wide-character
constants are a Microsoft extension to DCE IDL. To enable the use of the data
type wchar_t, use the MIDL compiler switch /ms_ext or /c_ext.
MIDL2013
: use of wide-character strings requires /ms_ext or /c_ext
Wide-character
string constants are a Microsoft extension to DCE IDL. To enable the use of the
data type wchar_t, use the MIDL compiler switch /ms_ext or /c_ext.
MIDL2014
: inconsistent redefinition of type wchar_t
The type wchar_t
has been redefined as a type that is not equivalent to unsigned short.
MIDL2017
: syntax error
The compiler
detected a syntax error at the specified line.
MIDL2018
: cannot recover from earlier syntax errors; aborting compilation
The MIDL
compiler automatically tries to recover from syntax errors by adding or
removing syntactic elements. This message indicates that despite these attempts
to recover, the compiler detected too many errors. Correct the specified
error(s) and recompile.
MIDL2019
: unknown pragma option
The specified
C pragma is not supported in MIDL. Remove the pragma from the IDL file.
MIDL2020
: feature not implemented
The MIDL
feature, although part of the language definition, is not implemented in
Microsoft RPC and is not supported by the MIDL compiler. For example, the
following language features are not implemented: bitset, pipe, and the
international character type. The unimplemented language feature appears in the
additional-information field of the error message.
MIDL2021
: type not implemented
The specified
data type, although a legal MIDL keyword, is not implemented in Microsoft RPC.
MIDL2022
: non-pointer used in a dereference operation
A data type
that is not a pointer has been associated with pointer operations. You cannot
access the object through the specified non-pointer.
MIDL2023
: expression has a divide by zero
The constant
expression contains a divide by zero.
MIDL2024
: expression uses incompatible types
The left and
right sides of the operator in an expression are of incompatible types.
MIDL2025
: non-array expression uses index operator
The expression
uses the array-indexing operation on a data item that is not of the array type.
MIDL2026
: left-hand side of expression does not evaluate to struct/union/enum
The direct or
indirect reference operator . or -> has been applied to a data object
that is not a structure, union, or enum. You cannot obtain a direct or
indirect reference using the specified object.
MIDL2027
: constant expression expected
A constant
expression was expected in the syntax. For example, array bounds require a
constant expression. The compiler issues this error message when the array
bound is defined with a variable or undefined symbol.
MIDL2028
: expression cannot be evaluated at compile time
The compiler
cannot evaluate an expression at compile time.
MIDL2029
: expression not implemented
A feature
that was supported in previous releases of the MIDL compiler is not supported
in the version of the compiler supplied with Microsoft RPC. Remove the
specified feature.
MIDL2030
: no [pointer_default] specified, assuming [unique] for all unattributed
pointers
The MIDL
compiler offers three different default cases for pointers that do not have
pointer attributes. Function parameters that are top-level pointers default to ref
pointers. Pointers embedded in structures and pointers to other pointers (not
top-level pointers) default to the type specified by the pointer_default
attribute. When no pointer_default attribute is supplied, these
non-top-level pointers default to unique pointers. This error message indicates
the last case: no pointer_default attribute is supplied and there is at
least one non-top-level pointer that will be treated as a unique pointer.
MIDL2031
: [out] only parameter cannot be a pointer to an open structure
An out-only
parameter has been used as a pointer to a structure, known as an open
structure, whose transmitted range and size are determined at run time. The
server stub does not know how much space to allocate for an open structure. Use
a pointer to a pointer to the open structure and ensure that the server application
allocates sufficient space for it.
MIDL2032
: [out] only parameter cannot be an unsized string
An array with
the string attribute has been declared as an out-only parameter without
any size specification. The server stub needs size information to allocate
memory for the string. You can remove the string attribute and add the size_is
attribute, or you can change the parameter to an in, out parameter.
MIDL2033
: [out] parameter is not a pointer
All out
parameters must be pointers, in keeping with the call-by-value convention of
the C programming language. The out directional parameter indicates that
the server transmits a value to the client. With the call-by-value convention,
the server can transmit data to the client only if the function argument is a
pointer.
MIDL2034
: open structure cannot be a parameter
A structure
or union is truncated when the last element of that structure or union is a
conformant array.
MIDL2035
: [out] context handle/generic handle must be specified as a pointer to that
handle type
A
context-handle or user-defined handle parameter with the out directional
attribute must be a pointer to a pointer.
MIDL2036
: [context_handle] must not derive from a type that has the [transmit_as]
attribute
Context
handles must be transmitted as context-handle types. They cannot be transmitted
as other types.
MIDL2037
: cannot specify a variable number of arguments to a remote procedure
Remote
procedure calls that specify the number of variable arguments at compile time
are not compatible with the DCE RPC definition. You cannot use a variable
number of arguments in Microsoft RPC.
MIDL2038
: named parameter cannot be void
A parameter
with the base type void is specified with a name.
MIDL2040
: cannot use [comm_status] on both a parameter and a return type
Both the
procedure and one of its parameters have the comm_status attribute. The comm_status
attribute specifies that only one data object can be of type error_status_t
at a time.
MIDL2041
: [local] attribute on a procedure requires /ms_ext
A procedure
uses the local attribute as a function attribute, which is not
compatible with DCE RPC. To enable the Microsoft RPC extensions, use the MIDL
compiler switch /ms_ext.
MIDL2042
: field deriving from a conformant array must be the last member of the
structure
The structure
contains a conformant array that is not the last element in the structure. The
conformant array must appear as the last structure element.
MIDL2043
: duplicate [case] label
A duplicate
case label has been specified. The duplicate label is displayed.
MIDL2044
: no [default] case specified for discriminated union
A
discriminated union has been specified without a default case.
MIDL2045
: attribute expression cannot be resolved
The
expression associated with the attribute cannot be resolved. This error usually
occurs when a variable that appears in the expression is not defined. For
example, the error can occur when the variable s is not defined and is
used by the attribute size_is(s).
MIDL2046
: attribute expression must be of integral type
The specified
attribute variable or expression must be an integral type. This error occurs
when the attribute-expression type does not resolve to an integer.
MIDL2047
: [byte_count] requires /ms_ext
The byte_count
attribute represents an extension to DCE RPC. To enable the Microsoft RPC
extensions, use the MIDL compiler switch /ms_ext.
MIDL2048
: [byte_count] can be applied only to out parameters of pointer type
The byte_count
attribute can only be applied to out parameters, and all out
parameters must be pointer types.
MIDL2049
: [byte_count] cannot be specified on a pointer to a conformant array or
structure
The byte_count
attribute cannot be applied to a conformant array or structure.
MIDL2050
: parameter specifying the byte count is not [in]
The value
associated with the byte_count must be transmitted from the client to
the server; it must be an in parameter. The byte_count parameter
does not need to be an in, out parameter.
MIDL2051
: parameter specifying the byte count is not an integral type
The value
associated with the byte count must be the integer type small, short,
or long.
MIDL2052
: [byte_count] cannot be specified on a parameter with size attributes
The byte_count
attribute cannot be used with other size attributes such as size_is or length_is.
MIDL2053
: [case] expression is not constant
The
expression specified for the case label is not a constant.
MIDL2054
: [case] expression is not of integral type
The
expression specified for the case label is not an integer type.
MIDL2055
: specifying [context handle] on a type other than void * requires /ms_ext
For DCE RPC
compatibility, the context handle must be a pointer of type void *. To
use the Microsoft RPC extensions that allow context handles to be associated
with types other than void *, use the MIDL compiler switch /ms_ext.
MIDL2056
: cannot specify more than one parameter with each of comm_status/fault_status
The comm_status
attribute may only appear once, and the fault_status attribute may
only appear once per procedure.
MIDL2057
: error_status_t parameter must be an [out] only pointer parameter
The
error-code type error_status_t is transmitted from server to client and
therefore must be specified as an out parameter. Due to the constraints
in the C programming language, all out parameters must be pointers.
MIDL2058
: endpoint syntax error
The endpoint
syntax is incorrect.
MIDL2059
: inapplicable attribute
The specified
attribute cannot be applied in this construct. For example, the string
attribute applies to char arrays or char pointers and cannot be
applied to a structure that consists of two short integers:
typedef [string] struct foo {
short x;
short y;
};
MIDL2060
: [allocate] requires /ms_ext
The allocate
attribute represents a Microsoft extension that is not defined as part of DCE
RPC. To enable the Microsoft extensions, use the /ms_ext switch.
MIDL2061
: invalid [allocate] mode
An invalid
mode for the allocate attribute construct has been specified. The four
valid modes are single_node, all_nodes, on_null, and always.
MIDL2062
: length attributes cannot be applied with string attribute
When the
string attribute is used, the generated stub files call the strlen
function to determine the string length. Don t use the length attribute and the
string attribute for the same variable.
MIDL2063
: [last_is] and [length_is] cannot be specified at the same time
Both last_is
and length_is have been specified for the same array. These attributes
are related as follows: length = last - first + 1. Because each value can be
derived from the other, don t specify both.
MIDL2064
: [max_is] and [size_is] cannot be specified at the same time
Both max_is
and size_is have been specified for the same array. These attributes are
related as follows: max = size + 1. Because each value can be derived from the
other, don t specify both.
MIDL2065
: no [switch_is] attribute specified at use of union
No
discriminant has been specified for the union. The switch_is attribute
indicates the discriminant used to select among the union fields.
MIDL2066
: no [uuid] specified for interface
No UUID has
been specified for the interface.
MIDL2067
: cannot specify both [local] and [uuid] as interface attributes
The local and
UUID keywords cannot be used at the same time, except on [object] interfaces.
MIDL2068
: type mismatch between length and size attribute expressions
The length
and size attribute expressions must be of the same types. For example, this
warning is issued when the attribute variable for the size_is expression
is of type unsigned long and the attribute variable for the length_is
expression is of type long.
MIDL2069
: [string] attribute must be specified byte , char , or wchar_t array or
pointer
A string
attribute cannot be applied to a pointer or array whose base type is not a byte,
char, or struct in which the members are all of the byte
or char type.
MIDL2070
: mismatch between the type of the [switch_is] expression and the switch type
of the union
If the union switch_type
is not specified, the switch type is the same type as the switch_is
field.
MIDL2071
: [transmit_as] cannot be applied to a type that derives from a context handle
Context
handles cannot be transmitted as other types.
MIDL2072
: [transmit_as] must specify a transmissible type
The specified
transmit_as type derives from a type that cannot be transmitted by
Microsoft RPC, such as void, void *, or int. Use a defined
RPC base type; in the case of int, add size specifiers like small,
short, or long to qualify the int.
MIDL2073
: transmitted type must not be a pointer or derive from a pointer
The
transmitted type cannot be a pointer or derive from a pointer.
MIDL2074
: presented type must not derive from a conformant/varying array, its pointer
equivalent, or a conformant/varying structure
The type to
which transmit_as has been applied cannot derive from a conformant array
or structure (an array or structure whose size is determined at run time).
MIDL2075
: [uuid] format is incorrect
The UUID
format does not conform to specification. The UUID must be a string that
consists of five sequences of hexadecimal digits of length 8, 4, 4, 4, and 12
digits. 12345678-1234-ABCD-EF01-28A49C28F17D is a valid UUID. Use the
function UuidCreate or a utility to generate a valid UUID.
MIDL2076
: uuid is not a hex number
The UUID
specified for the interface contains characters that are invalid in a
hexadecimal number representation. The characters 0 through 9 and A through F
are valid in a hexadecimal representation.
MIDL2077
: interface name specified in the ACF file does not match that specified in the
IDL file
In this
compiler mode, the name that follows the interface keyword in the ACF must be
the same as the name that follows the interface keyword in the IDL file. The
interface names in the IDL and ACF files can be different when you compile with
the MIDL compiler switch /acf.
MIDL2078
: conflicting attributes
Conflicting
attributes have been specified. This error often occurs when two attributes are
mutually exclusive. For example, the attributes code and nocode
cannot be used at the same time.
MIDL2080
: [local] procedure cannot be specified in ACF file
A local
procedure has been specified in the ACF. The local procedure can only be
specified in the IDL file.
MIDL2081
: specified type is not defined as a handle
The
type specified in the implicit_handle attribute is not defined as a
handle type. Change the type definition or the type name specified by the
attribute.
MIDL2082
: procedure undefined
An attribute
has been applied to a procedure in the ACF and that procedure is not defined in
the IDL file.
MIDL2083
: this parameter does not exist in the IDL file
A parameter
specified in the ACF does not exist in the definition in the IDL file. All
parameters, functions, and type definitions that appear in the ACF must correspond
to parameters, functions, and types previously defined in the IDL file.
MIDL2084
: this array bounds construct is not supported
MIDL
currently supports array-bounds constructs of the form Array[Lower .. Upper]
only when the constant that specifies the lower bound of the array resolves to
the value zero.
MIDL2085
: array bound specification is illegal
The user
specification of array bounds for the fixed-size array is illegal. For example:
typedef short Array[-1]
MIDL2087
: pointee / array does not derive any size
A conformant
array has been specified without any size specification. You can specify the
size with the max_is or size_is attribute.
MIDL2088
: badly formed character constant
The
end-of-line character is not allowed in character constants.
MIDL2089
: end of file found in comment
The
end-of-file character has been encountered in a comment.
MIDL2090
: end of file found in string
The
end-of-file character has been encountered in a string.
MIDL2091
: identifier length exceeds 31 characters
Identifiers
are limited to 31 alphanumeric characters. Identifier names longer than 31
characters are truncated.
MIDL2092
: end of line found in string
The
end-of-line character has been encountered in the string. Verify that you have
included the double-quote character that terminates the string.
MIDL2093
: string constant exceeds limit of 255 characters
The string
exceeded the maximum allowable length of 255 characters.
MIDL2094
: constant too big
The constant
is too large to be represented internally.
MIDL2095
: error in opening file
The operating
system reported an error while trying to open an output file. This error can be
caused by a name that is too long for the file system or by a duplicate
filename.
MIDL2096
: [out] only parameter must not derive from a top-level [unique] or [ptr]
pointer/array
A unique
pointer cannot be an out-only parameter. By definition, a unique pointer
can change from null to non-null. No information about the out-only
parameter is passed from client to server.
MIDL2097
: attribute is not applicable to this non-rpcable union
The switch_is
and switch_type attributes apply to a union that is transmitted as part
of a remote procedure call.
MIDL2098
: expression used for a size attribute must not derive from an [out] only parameter
The value of
an out-only parameter is not transmitted to the server and cannot be
used to determine the length or size of the in parameter.
MIDL2099
: expression used for a length attribute for an [in] parameter cannot derive
from an [out] only parameter
The value of
an out-only parameter is not transmitted to the server and cannot be
used to determine the length or size of the in parameter.
MIDL2100
: use of int needs /c_ext
MIDL is a
strongly typed language. All parameters transmitted over the network must be
derived from one of the MIDL base types. The type int is not defined as
part of MIDL. Transmitted data must include a size specifier: small, short,
or long. Data that is not transmitted over the network can be included
in an interface; use the /c_ext switch.
MIDL2101
: struct/union field must not be void
Fields in a
structure or union must be declared to be of a specific base type supported by
MIDL or a type that is derived from the base types. Void types are not
allowed in remote operations.
MIDL2102
: array element must not be void
An array
element cannot be void.
MIDL2103
: use of type qualifiers and/or modifiers needs /c_ext
Type
modifiers such as _cdecl and _far can be compiled only if you
specify the /c_ext switch.
MIDL2104
: struct/union field must not derive from a function
The fields of
a structure or union must be MIDL base types or types that are derived from
these base types. Functions are not legal in structure or union fields.
MIDL2105
: array element must not be a function
An array
element cannot be a function.
MIDL2106
: parameter must not be a function
The parameter
to a remote procedure must be a variable of a specified type. A function cannot
be a parameter to the remote procedure.
MIDL2107
: struct/union with bit fields needs /c_ext
You must
specify the MIDL compiler switch /c_ext to allow bit fields on data that
is not transmitted in a remote procedure call.
MIDL2108
: bit field specification on a type other that int is a non ANSI-compatible
extension
The ANSI C
programming language specification does not allow bit fields to be applied to
non-integer types.
MIDL2109
: bit field specification can be applied only to simple, integral types
The ANSI C
programming language specification does not allow bit fields to be applied to
non-integer types.
MIDL2110
: struct/union field must not derive from handle_t or a context_handle
Context
handles cannot be transmitted as part of another structure. They must be
transmitted as context handles.
MIDL2111
: array element must not derive from handle_t or a context handle
Context
handles cannot be transmitted as part of an array.
MIDL2112
: this specification of union needs /c_ext
A union that
appears in the interface definition must be associated with the discriminant or
declared as local. Data that is not transmitted over the network can be
implicitly declared as local when you use the /c_ext switch.
MIDL2113
: parameter deriving from an int must have size specifier small , short ,
or long with the int
The type int
is not a valid MIDL type unless it is accompanied by a size specification. Use
one of the size specifiers small, short, or long.
MIDL2114
: type of the parameter cannot derive from void or void*
MIDL is a
strongly typed language. All parameters transmitted over the network must be
derived from one of the MIDL base types. MIDL does not support void as a
base type. You must change the declaration to a valid MIDL type.
MIDL2115
: parameter deriving from a struct/union containing bit fields is not supported
Bit fields
are not defined as a valid data type by DCE RPC.
MIDL2116
: use of a parameter deriving from a type containing
type-modifiers/type-qualifiers needs /c_ext
Such keywords
as far, near, const, and volatile can appear in the
IDL file only when you activate the /c_ext extension to the MIDL
compiler.
MIDL2117
: parameter must not derive from a pointer to a function
The RPC
run-time libraries transmit a pointer and its associated data between client
and server. Pointers to functions cannot be transmitted as parameters because
the function cannot be transmitted over the network.
MIDL2118
: parameter must not derive from a non-rpcable union
The union
must be associated with a discriminant. Use the switch_is and switch_type
attributes.
MIDL2119
: return type derives from an int . You must use size specifiers with the
int
The type int
is not a valid MIDL type unless it is accompanied by a size specification. Use
one of the size specifiers small, short, or long.
MIDL2120
: return type must not derive from a void pointer
MIDL is a
strongly typed language. All parameters transmitted over the network must be
derived from one of the MIDL base types. Void types are not defined as
part of MIDL. You must change the declaration to a valid MIDL type.
MIDL2121
: return type must not derive from a struct/union containing bit-fields
Bit fields
are not defined as a valid data type by DCE RPC.
MIDL2122
: return type must not derive from a non-rpcable union
The union
must be associated with a discriminant. Use the switch_is and switch_type
attributes.
MIDL2123
: return type must not derive from a pointer to a function
The RPC
run-time libraries transmit a pointer and its associated data between client
and server. Pointers to functions cannot be transmitted as parameters because
RPC does not define a method to transmit the associated function over the
network.
MIDL2124
: compound initializers are not supported
DCE RPC
supports simple initialization only. The structure or array cannot be
initialized in the IDL file.
MIDL2125
: ACF attributes in the IDL file need the /app_config switch
A Microsoft
extension allows you to specify ACF attributes in the IDL file. Use the /app_config
switch to activate this extension.
MIDL2126
: single line comment needs /ms_ext or /c_ext
Single-line
comments that use two slash characters (//) represent a Microsoft extension to
DCE RPC. You must use one of the mode-extension switches for a single-line
comment.
MIDL2127
: [version] format is incorrect
The interface
version number in the interface header must be specified in the format major.minor,
where each number can range from 0 to 65535.
MIDL2128
: signed needs /ms_ext or /c_ext
The use of
the signed keyword is a Microsoft extension to DCE RPC. You must use one
of the mode-extension switches to activate this extension.
MIDL2129
: mismatch in assignment type
The type of
the variable does not match the type of the value that is assigned to the
variable.
MIDL2130
: declaration must be of the form: const <type><declarator> =
<initializing expression>
The
declaration is not compatible with DCE RPC syntax. Use the /ms_ext or /c_ext
MIDL compiler mode switch.
MIDL2131
: declaration must have const
Declarations
in the IDL file must be constant expressions that use the keyword const.
For example:
const short x = 2;
MIDL2132
: struct/union/enum must not be defined in a parameter type specification
The
structure, union, or enumerated type must be explicitly specified outside of
the function prototype.
MIDL2133
: [allocate] attribute must be applied only on non-void pointer types
The allocate
attribute is designed for complex pointer-based data structures. When the allocate
attribute is specified, the stub file traverses the data structure to compute the
total size of all objects accessible from the pointer and all other pointers in
the data structure. Change the type to a non-void pointer type or remove the allocate
attribute and use another method to determine its allocation size, such as the sizeof
operator.
MIDL2134
: array or equivalent pointer construct cannot derive from a non-encapsulated
union
Each union
must be associated with a discriminant. Arrays of unions are not permitted
because they do not provide the associated discriminant. Arrays of structures
are permitted because each structure consists of the union and its
discriminant.
MIDL2135
: field must not derive from an error_status_t type
The error_status_t
type can only be used as a parameter or a return type. It cannot be embedded in
the field of a structure or union.
MIDL2136
: union has at least one arm without a case label
The union
declaration does not match the required MIDL syntax for the union. Each union
arm requires a case label or default label that selects that union arm.
MIDL2137
: a parameter or a return value must not derive from a type which has [ignore]
applied to it
The ignore
attribute is a field attribute that can only be applied to fields, such as
fields of structures and arrays. The ignore attribute indicates that the
stub should not dereference the pointer during transmission and is not allowed
when it conflicts with other attributes that must be dereferenced, such as out
parameters and function return values.
MIDL2138
: pointer already has a pointer-attribute applied to it
Only one of
the pointer attributes, ref, unique, or ptr, can be
applied to a pointer.
MIDL2139
: field/parameter must not derive from a structure that is recursive through a
ref pointer
By definition,
a reference pointer cannot be set to NULL. A recursive data structure defined
with a reference pointer has no null elements and by convention is
non-terminating. Use a unique pointer attribute to allow the data
structure to specify a null element or redefine the data structure as a
non-recursive data structure.
MIDL2140
: use of field deriving from a void pointer needs /c_ext
The type void
* and other types and type qualifiers that are not supported by DCE IDL are
only allowed in the IDL file when you use the MIDL compiler switch /c_ext.
Redefine the pointer type or recompile using the /c_ext switch.
MIDL2141
: use of this attribute needs /ms_ext
This language
feature is a Microsoft extension to DCE IDL. You must specify the MIDL compiler
switch /ms_ext.
MIDL2142
: use of wchar_t needs /ms_ext or /c_ext
The
wide-character type represents an extension to DCE IDL. The MIDL compiler
accepts the wide-character type only when you specify the /ms_ext or /c_ext
switch.
MIDL2143
: unnamed fields need /ms_ext or /c_ext
DCE IDL does
not support the use of unnamed structures or unions embedded in other
structures or unions. In DCE IDL, all such embedded fields must be named. To
enable this Microsoft extension to IDL, supply the MIDL compiler switch /ms_ext
or /c_ext.
MIDL2144
: unnamed fields can derive only from struct/union types
The Microsoft
extension to the DCE IDL that supports unnamed fields applies only to
structures and unions. You must assign a name to the field or redefine the
field to comply with this restriction.
MIDL2145
: field of a union cannot derive from a varying/conformant array or its pointer
equivalent
The
conformant array cannot appear alone in the union but must be accompanied by
the value that specifies the size of the array. Instead of using the array as
the union arm, use a structure that consists of the conformant array and the
identifier that specifies the size.
MIDL2146
: no [pointer_default] attribute specified, assuming [ptr] for all unattributed
pointers in interface
The DCE IDL
implementation specifies that all pointers in each IDL file must be associated with
pointer attributes. When an explicit pointer attribute is not assigned to the
parameter or pointer type and no pointer_default attribute is specified
in the IDL file, the full pointer attribute ptr is associated with the
pointer. You can change the pointer attributes by using explicit pointer
attributes, by specifying a pointer_default attribute, or by specifying
the /ms_ext switch to change the default for unattributed pointers to unique.
MIDL2147
: initializing expression must resolve to a constant expression
The use of
initializing expressions is limited to constant expressions in all MIDL
compiler modes. The expression must be resolvable at compile time. Specify a
literal constant, or an expression that resolves to a constant, rather than a
variable.
MIDL2148
: attribute expression must be of type integer, char, byte, boolean or enum
The specified
type does not resolve to a valid switch type. Use an integer, character, byte,
boolean, or enum type, or a type that is derived from one of
these types.
MIDL2149
: illegal constant
The specified
constant is out of the valid range for the specified type.
MIDL2150
: attribute not implemented; ignored
The attribute
specified is not implemented in this release of Microsoft RPC. The MIDL
compiler continues processing the IDL file as if the attribute were not
present.
MIDL2151
: return value must not derive from a [ref] pointer
Function
return values that are defined to be pointer types must be specified as unique
or full pointers. Reference pointers cannot be used.
MIDL2152
: attribute expression must be a variable name or a pointer dereference
expression in this mode. You must specify the /ms_ext switch
The DCE IDL
compiler requires the size associated with the size_is attribute to be
specified by a variable or pointer variable. To enable the Microsoft extension
that allows the size_is attribute to be defined by a constant
expression, use the /ms_ext switch.
MIDL2153
: parameter must not derive from a recursive non-encapsulated union
A union must
include a discriminant, so a union cannot have another union as an element. A
union can be embedded in another union only when it is part of a structure that
includes the discriminant.
MIDL2154
: binding-handle parameter cannot be [out] only
The handle
parameter identified by the MIDL compiler as the binding handle for this
operation must be an in parameter. Out-only parameters are
undefined on the client stub, and the binding handle must be defined on the
client.
MIDL2155
: pointer to a handle cannot be [unique] or [ptr]
The unique
and full pointer attributes allow the value NULL. The binding handle cannot be
null. Use the ref attribute to derive the binding-handle parameter from
reference pointers.
MIDL2156
: parameter that is not a binding handle must not derive from handle_t
The primitive
handle type handle_t is not a valid data type that is transmitted over
the network. Change the parameter type to a type other than handle_t or
remove the parameter.
MIDL2157
: unexpected end of file found
The MIDL
compiler found the end of the file before it was able to successfully resolve
all syntactical elements of the file. Verify that the terminating right brace
character (}) is present at the end of the file, or check the syntax.
MIDL2158
: type deriving from handle_t must not have [transmit_as] applied to it
The primitive
handle type handle_t is not transmitted over the network.
MIDL2159
: [context_handle] must not be applied to a type that has [handle] applied to
it
The context_handle
and handle attributes cannot be applied to the same type.
MIDL2160
: [handle] must not be specified on a type deriving from void or void *
A type
specified with the handle attribute can be transmitted over the network,
but the type void * is not a transmissible type. The handle type must
resolve to a type that derives from the valid base types.
MIDL2161
: parameter must have either [in], [out] or [in,out] in this mode. You must
specify /ms_ext or /c_ext
The DCE IDL
compiler requires all parameters to have explicit directional parameters. To
use the Microsoft extensions to DCE IDL, where you can omit explicit
directional attributes, use the MIDL compiler switch /ms_ext or /c_ext.
MIDL2162
: [transmit_as] must not be specified on void type
The transmit_as
attribute applies only to pointer types. Use the type void * in place of
void.
MIDL2163
: void must be specified on the first and only parameter specification
The keyword void
incorrectly appears with other function parameters. To specify a function
without parameters, the keyword void must be the only element of the
parameter list, as in the following example:
void Foo(void)
MIDL2164
: [switch_is] must be specified only on a type deriving from a non-encapsulated
union
The switch_is
keyword is incorrectly applied. It can only be used with non-encapsulated union
types. For more information, see the syntax section in the reference entry for non-encapsulated
unions.
MIDL2165
: stringable structures are not implemented in this version
DCE IDL
allows the attribute string to apply to a structure whose elements consist only
of characters, bytes, or types that resolve to characters or bytes. This
functionality is not supported in Microsoft RPC. The string attribute cannot be
applied to the structure as a whole; it can be applied to each individual array.
MIDL2166
: switch type can only be integral, char, byte, boolean or enum
The specified
type does not resolve to a valid switch type. Use an integer, character, byte,
boolean, or enum type, or a type that is derived from one of
these types.
MIDL2167
: [handle] must not be specified on a type deriving from handle_t
A handle type
must be defined using one and only one of the handle types or attributes. Use
the primitive type handle_t or the attribute handle, but not
both. The user-defined handle type must be transmissible, but the handle_t
type is not transmitted on the network.
MIDL2168
: parameter deriving from handle_t must not be an [out] parameter
A handle of
the primitive type handle_t is meaningful only to the side of the
application in which it is defined. The type handle_t is not transmitted
on the network.
MIDL2169
: expression specifying size or length attributes derives from [unique] or
[ptr] pointer dereference
Although the
unique and full pointer attributes allow pointers to have null values, the
expression that defines the size or length attribute must never have a null
value. When pointers are used, MIDL constrains expressions to ref
pointers.
MIDL2170
: cpp_quote requires /ms_ext
The cpp_quote
attribute is a Microsoft extension to DCE IDL. Use the MIDL compiler switch /ms_ext.
MIDL2171
: quoted uuid requires /ms_ext
The ability
to specify a UUID value within quotation marks is a Microsoft extension to DCE
IDL. Use the MIDL compiler switch /ms_ext.
MIDL2172
: return type cannot derive from a non-encapsulated union
The
non-encapsulated union cannot be used as a function return type. To return the
union type, specify the union type as an out or in, out
parameter.
MIDL2173
: return type cannot derive from a conformant structure
The size of
the return type must be a constant. You cannot specify as a return type a
structure that contains a conformant array even when the structure also
includes its size specifier. To return the conformant structure, specify the
structure as an out or in, out parameter.
MIDL2174
: [transmit_as] must not be applied to a type deriving from a generic handle
In this
release, the handle and transmit_as attributes cannot be combined
on the same type.
MIDL2175
: [handle] must not be applied to a type that has [transmit_as] applied to it
In this
release, the handle and transmit_as attributes cannot be combined
on the same type.
MIDL2176
: type specified for the const declaration is invalid
Const declarations are limited to integer, character,
wide-character, string, and boolean types.
MIDL2177
: operand to the sizeof operator is not supported
The MIDL
compiler supports the sizeof operation for simple types only.
MIDL2178
: this name already used as an const identifier name
The
identifier has previously been used to identify a constant in a const
declaration. Change the name of one of the identifiers so that the identifiers
are unique.
MIDL2179
: inconsistent redefinition of type error_status_t
The type error_status_t
must resolve to the type unsigned long. Other type definitions cannot be
used.
MIDL2180
: [case] value out of range of switch type
The value
associated with the switch statement case is out of range for the specified
switch type. For example, this error occurs when a long integer value is used
in the case statement for a short integer type.
MIDL2181
: parameter deriving from wchar_t needs /ms_ext
The
wide-character type wchar_t is a Microsoft extension to DCE IDL. Use the
MIDL compiler switch /ms_ext.
MIDL2182
: this interface has only callbacks
Callbacks are
valid only in the context of a remote procedure call. The interface must
include at least one function prototype for a remote procedure call that does
not include the callback attribute.
MIDL2183
: redundantly specified attribute; ignored
The specified
attribute has been applied more than once. Multiple instances of the same
attribute are ignored.
MIDL2184
: context handle type used for an implicit handle
A type that
was defined using the context_handle attribute has been specified as the
handle type in an implicit_handle attribute. The attributes cannot be
combined in this way.
MIDL2185
: conflicting options specified for [allocate]
The options
specified for the ACF attribute allocate represent conflicting
directives. For example, specify either the option all_nodes or the
option single_node, but not both.
MIDL2186
: error while writing to file
An error
occurred while writing to the file. This condition can be caused by errors
relating to disk space, file handles, file-access restrictions, and hardware
failures.
MIDL2187
: no switch type found at definition of union, using the [switch_is] type
The union
definition does not include an explicit switch_type attribute. The type
of the variable specified by the switch_is attribute is used as the
switch type.
MIDL2188
: semantic check incomplete due to previous errors
The MIDL
compiler makes two passes over the input file(s) to resolve any forward
declarations. Due to errors encountered during the first pass, checking for the
second pass has not been performed. Unreported errors relating to forward
declarations may still be present in the file.
MIDL2189
: handle parameter or return type is not supported on a [callback] procedure
A callback
procedure occurs in the context of a call from a client to the server and uses
the same binding handle as the original call. Explicit binding-handle
parameters or return types are not permitted in callback functions.
MIDL2192
: [context_handle] must not derive from handle_t
The three
handle characteristics the type handle_t,
the attribute handle, and the attribute context_handle are mutually exclusive. Only one can be applied to a
type or parameter at a time.
MIDL2193
: array size exceeds 65536 bytes
On some
Microsoft platforms, the maximum transmissible data size is 64K. Redesign your
application so that all transmitted data fits within the maximum transmissible
size.
MIDL2194
: field of a non-encapsulated union cannot be another non-encapsulated union
Unions that
are transmitted as part of a remote procedure call require an associated data
item, the discriminant, that selects the union arm. Unions nested in other
unions do not offer a discriminant; as a result, they cannot be transmitted in
this form. Create a structure that consists of the union and its discriminant.
MIDL2195
: pointer attribute(s) applied on an embedded array; ignored
A pointer
attribute can be applied to an array only when the array is a top-level
parameter. Other pointer attributes applied to arrays embedded in other data
structures are ignored.
MIDL2196
: [allocate] is illegal on a type that has [transmit_as] applied to it
The transmit_as
and allocate attributes cannot both be applied to the same type. The transmit_as
attribute distinguishes between presented and transmitted types, while the allocate
attribute assumes that the presented type is the same as the transmitted type.
MIDL2198
: [implicit_handle] type undefined; assuming primitive handle
The handle
type specified in the ACF is not defined in the IDL file. The MIDL compiler assumes
that the handle type resolves to the primitive handle type handle_t. Add
the handle attribute to the type definition if you want the handle to
behave like a user-defined, or generic, handle.
MIDL2199
: array element must not derive from error_status_t
In this
release of Microsoft RPC, the type error_status_t can only appear as a
parameter or a return type. It cannot appear in arrays.
MIDL2200
: [allocate] illegal on a type deriving from a primitive/generic/context handle
By design,
the ACF attribute allocate cannot be applied to handle types.
MIDL2201
: transmitted or presented type must not derive from error_status_t
In this
release of Microsoft RPC, the type error_status_t cannot be used with
the transmit_as attribute.
MIDL2202
: discriminant of a union must not derive from a field with [ignore] applied to
it
A union used
in a remote procedure call must be associated with another data item, called
the discriminant, that selects the union arm. The discriminant must be
transmitted. The ignore attribute cannot be applied to the union
discriminant.
MIDL2203
: [nocode] must be specified with /server none in this mode
Some DCE IDL
compilers generate an error when the nocode attribute is applied to a
procedure in an interface for which server stub files are being generated.
Because the server must support all operations, nocode must not be
applied to a procedure in this mode or you must use the MIDL compiler switch /server
none to explicitly specify that no server routines are to be generated.
MIDL2204
: no remote procedures specified, no client/server stubs will be generated
The provided
interface does not have any remote procedures, so only header files will be
generated.
MIDL2205
: too many default cases specified for encapsulated union
An encapsulated
union may only have one default: arm.
MIDL2206
: union specification with no fields is illegal
Unions must
have at least one field.
MIDL2207
: value out of range
The provided
case value is out of the range of the switch type.
MIDL2208
: [context_handle] must be applied on a pointer type
Context
handles must always be pointer types. DCE specifies that all context handles
must be typed as void * .
MIDL2209
: return type must not derive from handle_t
Handle_t may
not be returned.
MIDL2210
: [handle] must not be applied to a type deriving from a context handle
A type may
not be both a context handle and a generic handle.
MIDL2211
: field deriving from an \ int\ must have size specifier \ small\ , \ short\ ,
or \ long\ with the \ int\
The use of
int is not remotable, since the size of int may be different accross
machines.
MIDL2212
: field must not derive from a void or void *
Void and void
* are not remotable types.
MIDL2213
: field must not derive from a struct containing bit-fields
bit fields in
structs are not remotable.
MIDL2214
: field must not derive from a non-rpcable union
A union must
be specified as a non-encapsulated union or encapsulated union in order to be
remoted. Ordinary C unions lack the discriminant needed to remote the union.
MIDL2215
: field must not derive from a pointer to a function
Pointers to functions
may not be remoted.
MIDL2216
: cannot use [fault_status] on both a parameter and a return type
[fault_status]
may only be used once per procedure, although [comm_status] may be used
independently.
MIDL2217
: return type too complicated for /Oi, using /Os
Large
by-value return types may only be handled by /Os optimization stubs. The stubs
for this routine will be generated using /Os optimization.
MIDL2218
: generic handle type too large for /Oi, using /Os
Large
by-value generic handle types may only be handled by /Os optimization stubs.
The stubs for this routine will be generated using /Os optimization.
MIDL2219
: [allocate(all_nodes)] on an [in,out] parameter may orphan the original memory
Use of
[allocate(all_nodes)] on an [in,out] parameter must re-allocate contiguous
memory for the [out] direction, thus orphaning the [in] parameter. This usage
is not recommended.
MIDL2220
: cannot have a [ref] pointer as a union arm
Ref pointers
must always point to valid memory, but an [in,out] union with a ref pointer may
return a ref pointer when the [in] direction used another type.
MIDL2222
: use of [comm_status] or [fault_status] not supported for /Oi, using /Os
[comm_status]
and [fault_status] may only be handled by /Os optimization stubs. The stubs for
this routine will be generated using /Os optimization.
MIDL2223
: use of an unknown type for [represent_as] not supported for /Oi, using /Os
Use of a
represent_as with a local type that is not defined in the idl file or an
imported idl file may only be handled by /Os optimization stubs. The stubs for
this routine will be generated using /Os optimization.
MIDL2224
: array types with [transmit_as] or [represent_as] not supported on return type
for /Oi, using /Os
Returning an
array with [transmit_as] or [represent_as] applied may only be handled by /Os
optimization stubs. The stubs for this routine will be generated using /Os
optimization.
MIDL2226
: [callback] requires /ms_ext
[callback] is
a Microsoft extension and requires use of the /ms_ext switch.
MIDL2227
: circular interface dependency
This
interface uses itself (directly or indirectly) as a base interface.
MIDL2228
: only IUnknown may be used as the root interface
Currently,
all interfaces must have IUnknown as the root interface.
MIDL2229
: [IID_IS] may only be applied to pointers to interfaces
[iid_is] can
only be applied to interface pointers, although they may be specified as
IUnknown *.
MIDL2230
: interfaces may only be used in pointer-to-interface constructs
Interface
names may not be used except as base interfaces or interface pointers.
MIDL2231
: interface pointers must have a UUID/IID
The base type
of the iid_is expression must be a UUID/GUID/IID type.
MIDL2232
: definitions and declarations outside of interface body requires /ms_ext
Putting
declarations and definitions outside of any interface body is a Microsoft
extension and requires the use of the /ms_ext switch.
MIDL2233
: multiple interfaces in one file requires /ms_ext
Using
multiple interfaces in a single idl file is a Microsoft extension and requires
the use of the /ms_ext switch.
MIDL2234
: only one of [implicit_handle], [auto_handle], or [explicit_handle] allowed
Each
interface may only have one of the above.
MIDL2235
: [implicit_handle] references a type which is not a handle
Implicit
handles must be of one of the handle types.
MIDL2236
: [object] procs may only be used with /env win32
[object]
interfaces may not be used with 16-bit environments.
MIDL2237
: [callback] with -env dos/win16 not supported for /Oi, using /Os
Callbacks in
16-bit environments may only be handled by /Os optimization stubs. The stubs
for this routine will be generated using /Os optimization.
MIDL2238
: float/double not supported as top-level parameter for /Oi, using /Os
Float and
double as parameters may only be handled by /Os optimization stubs. The stubs
for this routine will be generated using /Os optimization. Float and double
within structs/arrays/etc. May still be handled with /Oi.
MIDL2239
: pointers to context handles may not be used as return values
Context
handles must be used as direct return values, not indirect return values.
MIDL2240
: procedures in an object interface must return an HRESULT
All
non-[local] procedures in an object interface must return an HRESULT/SCODE.
MIDL2241
: duplicate UUID
UUIDs must be
unique.
MIDL2242
: [object] interfaces must derive from other [object] interfaces
Interface
inheritance is only allowed using object interfaces.
MIDL2243
: [IID_IS] expression must be a pointer to IID structure
The base type
of the iid_is expression must be a UUID/GUID/IID type.
MIDL2244
: [call_as] type must be a [local] procedure
Tthe target
of a call_as, if defined, must have [local] applied.
MIDL2245
: undefined [call_as] must not be used in an object interface [call_as]:
in_list
Another
routine defined in the ACf is attempting to use the same call_as routine as the
previous routine.
MIDL2246
: [auto_handle] may not be used with [encode] or [decode]
[encode] and
[decode] may only be used with explicit handles or implicit handles.
MIDL2247
: normal procs are not allowed in an interface with [encode] or [decode]
Interfaces
containing [encode] or [decode] procedures may not also have remoted procedures.
MIDL2248
: top-level conformance or variance not allowed with [encode] or [decode]
Types that
have top-level conformance or variance may not use type serialization, since
there is no way to provide sizing/lengthing. Structs containing them are, however,
allowed.
MIDL2249
: [out] parameters may not have \ const\
Since an
[out] parameter is altered, it may not have const.
MIDL2250
: return values may not have \ const\
Since a
function value is set, it must not have const.
MIDL2251
: multiple calling conventions illegal
Only one
calling convention may be applied to a single procedure.
MIDL2252
: attribute illegal on [object] procedure
The above
attribute only applies to procedures in interfaces that do not have [object].
MIDL2253
: [out] interface pointers must use double indirection
Since the
altered value is the pointer to the interface, there must be another level of
indirection above it to allow it to be returned.
MIDL2254
: procedure used twice as the caller in [call_as]
A given
[local] procedure may only be used once as the target of a [call_as], in order
to avoid name clashes.
MIDL2255
: [call_as] target must have [local] in an object interface
The target of
a call_as must be a defined, [local] procedure in the current interface.
MIDL2256
: [code] and [nocode] may not be used together
These two
attributes are contradictory, and may not be used together.
MIDL2257
: [maybe] procedures may not have a return value or [out] params
Since [maybe]
procedures may never return, there is no way to get returned values.
MIDL2258
: pointer to function must be used
Although
function type definitions are allowed in /c_ext mode, they may only be used as
pointers to functions (and may never be remoted).
MIDL2259
: functions may not be passed in an RPC operation
Functions and
function pointers may not be remoted.
MIDL2260
: hyper/double not supported as return value for /Oi, using /Os
Hyper and
double return values may only be handled by /Os optimization stubs. The stubs
for this routine will be generated using /Os optimization.
MIDL2261
: #pragma pack( pop ) without matching #pragma pack( push )
#pragma
pack(push) and #pragma pack(pop) must appear in matching pairs. At least one
too many #pragma pack(push)'s were specified.
MIDL2262
: stringable structure fields must be byte/char/wchar_t
[string] may
only be applied to a struct whose fields are all of type byte, or a type
definition equivalent of byte.
MIDL2263
: [notify] not supported for /Oi, using /Os
The [notify]
attribute may only be processed by /Os optimization stubs.
MIDL2264
: handle parameter or return type is not supported on a procedure in an
[object] interface
Handles may
not be used with [object] interfaces.
MIDL2265
: ANSI C only allows the leftmost array bound to be unspecified
In an
conformant array, ANSI C only allows the leftmost ( most significant ) array
bound to be unspecified. If multiple dimensions are conformant, MIDL will
attempt to put a 1 in the other conformant dimensions. If the other
dimensions are defined in a different typedef, this may not be possible. Try
putting all the array dimensions on the use of the array to avoid this. In any
case, beware of the array indexing calculations done by the compiler; you may
need to do your own calculations using the actual sizes.